home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / applets / collectn / incrseq.jav < prev    next >
Text File  |  1995-12-14  |  8KB  |  305 lines
  1. /*
  2.   File: IncrSeq.java
  3.  
  4.   Originally written by Doug Lea and released into the public domain. 
  5.   Thanks for the assistance and support of Sun Microsystems Labs, Agorics 
  6.   Inc, Loral, and everyone contributing, testing, and using this code.
  7.  
  8.   History:
  9.   Date     Who                What
  10.   24Sep95  dl@cs.oswego.edu   Create from collections.java  working file
  11.   13Oct95  dl                 Changed to use accessOnly
  12.  
  13. */
  14.   
  15. package collections;
  16.  
  17. import java.util.Enumeration;
  18. import java.util.NoSuchElementException;
  19.  
  20. /**
  21.  *
  22.  * Implementation of Immutable Seq
  23.  * @author Doug Lea
  24.  * @version 0.93
  25.  *
  26.  * <P> For an introduction to this package see <A HREF="index.html"> Overview </A>.
  27. **/
  28.  
  29. public final class IncrSeq extends IncrImpl implements Seq {
  30.  
  31.   private int indexArg_;
  32. /**
  33.  * Make a new pure Seq using the default underlying Seq implementation
  34. **/
  35.   public IncrSeq() { this(DefaultImplementations.seq()); }
  36.  
  37. /**
  38.  * Make a pure seq managing the given updatable seq s.
  39.  * Warning: Do not modify s during the the lifetime of the constructed pure seq!
  40. **/
  41.   public IncrSeq(UpdatableSeq s) { super(s); indexArg_ = 0; }
  42.  
  43. /**
  44.  * Make a copy. Uses lazy update.
  45. **/
  46.   protected Object clone() throws CloneNotSupportedException {
  47.     undelta();
  48.     IncrSeq s = new IncrSeq((UpdatableSeq)(updatable_));
  49.     nextVersion_ = s;
  50.     updatable_ = null;
  51.     op_ = NO_EDIT;
  52.     return s;
  53.   }
  54.  
  55. /**
  56.  * Implements collections.Seq.at.
  57.  * @see collections.Seq#at
  58. **/
  59.   public synchronized Object at(int index) 
  60.   throws  NoSuchElementException {
  61.     return ((UpdatableSeq)(accessOnly())).at(index);
  62.   }
  63.  
  64. /**
  65.  * Implements collections.Seq.first.
  66.  * @see collections.Seq#first
  67. **/
  68.   public synchronized Object first()
  69.   throws  NoSuchElementException {
  70.     return ((UpdatableSeq)(accessOnly())).first();
  71.   }
  72.  
  73. /**
  74.  * Implements collections.Seq.last.
  75.  * @see collections.Seq#last
  76. **/
  77.   public synchronized Object last()
  78.   throws  NoSuchElementException {
  79.     return ((UpdatableSeq)(accessOnly())).last();
  80.   }
  81.  
  82. /**
  83.  * Implements collections.Seq.firstIndexOf.
  84.  * @see collections.Seq#firstIndexOf
  85. **/
  86.   public synchronized int firstIndexOf(Object element, int startingIndex) {
  87.     return ((UpdatableSeq)(accessOnly())).firstIndexOf(element, startingIndex);
  88.   }
  89.    
  90. /**
  91.  * Implements collections.Seq.firstIndexOf.
  92.  * @see collections.Seq#firstIndexOf
  93. **/
  94.   public synchronized int firstIndexOf(Object element) {
  95.     return ((UpdatableSeq)(accessOnly())).firstIndexOf(element);
  96.   }
  97.  
  98. /**
  99.  * Implements collections.Seq.lastIndexOf.
  100.  * @see collections.Seq#lastIndexOf
  101. **/
  102.   public synchronized int lastIndexOf(Object element, int startingIndex) {
  103.     return ((UpdatableSeq)(accessOnly())).lastIndexOf(element, startingIndex);
  104.   }
  105.  
  106. /**
  107.  * Implements collections.Seq.lastIndexOf.
  108.  * @see collections.Seq#lastIndexOf
  109. **/
  110.   public synchronized int lastIndexOf(Object element) {
  111.     return ((UpdatableSeq)(accessOnly())).lastIndexOf(element);
  112.   }
  113.  
  114. /**
  115.  * Implements collections.Seq.subseq.
  116.  * Makes a full new Seq, not a lazy update.
  117.  * @see collections.Seq#subseq
  118. **/
  119.   public synchronized /* IncrSeq */ Seq  subseq(int index, int length) 
  120.   throws  NoSuchElementException {
  121.     return new IncrSeq(((UpdatableSeq)(((UpdatableSeq)accessOnly()).subseq(index, length))));
  122.   }
  123.  
  124.  
  125. /**
  126.  * Implements collections.Collection.removingOneOf
  127.  * @see collections.Collection#removingOneOf
  128. **/
  129.   public synchronized /* IncrSeq */ Collection  removingOneOf(Object element) {
  130.     undelta(); 
  131.     UpdatableSeq u = (UpdatableSeq)updatable_;
  132.     int idx = u.firstIndexOf(element);
  133.     if (idx < 0)
  134.       return this;
  135.     else {
  136.       try {
  137.         u.removeAt(idx);
  138.       }
  139.       catch (NoSuchElementException ex) {} // can't happen
  140.       IncrSeq s = new IncrSeq(u);
  141.       nextVersion_ = s;
  142.       updatable_ = null;
  143.       firstObjectArg_ = element;
  144.       indexArg_ = idx;
  145.       op_ = ADD_EDIT;
  146.       return s;
  147.     }
  148.   }
  149.  
  150. /**
  151.  * Implements collections.Collection.excluding.
  152.  * If more than one occurrence of element exists, it makes
  153.  * a full, non-lazy copy.
  154.  * @see collections.Collection#excluding
  155. **/
  156.   public synchronized /* IncrSeq */ Collection  excluding(Object element) {
  157.     undelta(); 
  158.     UpdatableSeq u = (UpdatableSeq)updatable_;
  159.     int occ = u.occurrencesOf(element);
  160.     if (occ == 0)
  161.       return this;
  162.     else if (occ == 1)
  163.       return this.removingOneOf(element);
  164.     else {
  165.       UpdatableSeq c = (UpdatableSeq)(u.duplicate());
  166.       c.exclude(element);
  167.       return new IncrSeq(c);
  168.     }
  169.   }
  170.  
  171.  
  172. /**
  173.  * Implements collections.Collection.replacingOneOf
  174.  * @see collections.Collection#replacingOneOf
  175. **/
  176.   public synchronized /* IncrSeq */ Collection  replacingOneOf(Object oldElement,
  177.                                                     Object newElement) 
  178.   throws IllegalElementException {
  179.     undelta(); 
  180.     UpdatableSeq u = (UpdatableSeq)updatable_;
  181.     int idx = u.firstIndexOf(oldElement);
  182.     if (idx < 0)
  183.       return this;
  184.     else {
  185.       try {
  186.         u.replaceAt(idx, newElement);
  187.       }
  188.       catch (NoSuchElementException ex) {} // can't happen
  189.       IncrSeq s = new IncrSeq(u);
  190.       nextVersion_ = s;
  191.       updatable_ = null;
  192.       firstObjectArg_ = oldElement;
  193.       op_ = REPLACE_EDIT;
  194.       indexArg_ = idx;
  195.       return s;
  196.     }
  197.   }
  198.  
  199. /**
  200.  * Implements collections.Collection.replacingAllOf.
  201.  * If more than one occurrence of element exists, it makes
  202.  * a full, non-lazy copy.
  203.  * @see collections.Collection#replacingAllOf
  204. **/
  205.   public synchronized /* IncrSeq */ Collection  replacingAllOf(Object oldElement,
  206.                                                         Object newElement) 
  207.   throws IllegalElementException {
  208.     undelta(); 
  209.     UpdatableSeq u = (UpdatableSeq)updatable_;
  210.     int oldocc = u.occurrencesOf(oldElement);
  211.     if (oldocc == 0)
  212.       return this;
  213.     else if (oldocc == 1)
  214.       return this.replacingOneOf(oldElement, newElement);
  215.     else {
  216.       UpdatableSeq c = (UpdatableSeq)(u.duplicate());
  217.       c.replaceAllOf(oldElement, newElement);
  218.       return new IncrSeq(c);
  219.     }
  220.   }
  221.  
  222.  
  223.  
  224. /**
  225.  * Implements collections.Seq.insertingAt.
  226.  * @see collections.Seq#insertingAt
  227. **/
  228.   public synchronized /* IncrSeq */ Seq  insertingAt(int index, Object element) 
  229.   throws IllegalElementException, NoSuchElementException {
  230.     undelta(); 
  231.     UpdatableSeq u = (UpdatableSeq)updatable_;
  232.     u.insertAt(index, element);
  233.     IncrSeq s = new IncrSeq(u);
  234.     nextVersion_ = s;
  235.     updatable_ = null;
  236.     indexArg_ = index;
  237.     op_ = REMOVE_EDIT;
  238.     return s;
  239.   }
  240.  
  241. /**
  242.  * Implements collections.Seq.removingAt.
  243.  * @see collections.Seq#removingAt
  244. **/
  245.   public synchronized /* IncrSeq */ Seq  removingAt(int index) 
  246.   throws NoSuchElementException {
  247.     undelta(); 
  248.     UpdatableSeq u = (UpdatableSeq)updatable_;
  249.     Object element = u.at(index);
  250.     u.removeAt(index);
  251.     IncrSeq s = new IncrSeq(u);
  252.     nextVersion_ = s;
  253.     updatable_ = null;
  254.     indexArg_ = index;
  255.     firstObjectArg_ = element;
  256.     op_ = ADD_EDIT;
  257.     return s;
  258.   }
  259.  
  260. /**
  261.  * Implements collections.Seq.replacingAt
  262.  * @see collections.Seq#replacingAt
  263. **/
  264.   public synchronized /* IncrSeq */ Seq  replacingAt(int index, Object element) 
  265.   throws IllegalElementException, NoSuchElementException {
  266.     undelta(); 
  267.     UpdatableSeq u = (UpdatableSeq)updatable_;
  268.     Object oldElement = u.at(index);
  269.     if (oldElement.equals(element))
  270.       return this;
  271.     else {
  272.       u.replaceAt(index, element);
  273.       IncrSeq s = new IncrSeq(u);
  274.       nextVersion_ = s;
  275.       updatable_ = null;
  276.       indexArg_ = index;
  277.       firstObjectArg_ = oldElement;
  278.       op_ = REPLACE_EDIT;
  279.       return s;
  280.     }
  281.   }
  282.  
  283.  
  284. /**
  285.  * Perform updates within an edit chain
  286. **/
  287.   protected synchronized UpdatableCollection doEdit(UpdatableCollection c) { 
  288.     UpdatableSeq u = (UpdatableSeq)c;
  289.     try { 
  290.       if (op_ == ADD_EDIT) 
  291.         u.insertAt(indexArg_, firstObjectArg_);
  292.       else if (op_ == REMOVE_EDIT)
  293.         u.removeAt(indexArg_);
  294.       else if (op_ == REPLACE_EDIT)
  295.         u.replaceAt(indexArg_, firstObjectArg_);
  296.     }
  297.     catch (IllegalElementException ex) {} // we've screened for all possible
  298.     catch (NoSuchElementException ex) {} 
  299.     return u;
  300.   }
  301.  
  302.  
  303. }
  304.  
  305.